/**
 * 文本转化为 数组文本
 * @param  {String} str 原始文本
 */
export function getContent(str) {
    const arr = [];
    for (let i = 0; i < str.length; i++) {
        arr.push(str.charAt(i));
    }
    return arr;
}


/**
 * 划词后 文本转化
 * @param  {Array} arr 划词后数组
 * @param  {Object} obj 划词
 * @param dom
 * @param  {number} model 划词模式 默认为 1
 */
export function getMarkContent(arr, obj, dom, model, uuid) {
    let content = `${obj.text}$_#_$`;
    if (model === 0) {
        content += `${dom.labelText}`
    } else {
        content += `${dom.getAttribute('text')}`
    }
    content += `$_#_$${dom.id}$_#_$${uuid}`;
    arr.splice(obj.startIndex, obj.endIndex - obj.startIndex + 1, content)
    return arr;
}

/**
 * 语音标注 文本转化
 * @param  {Array} arr 划词后数组
 * @param  {Object} obj 划词
 * @param dom
 * @param  {number} model 划词模式 默认为 1
 */
export function getAudioMarkContent(arr, obj, dom, model, uuid) {
  let content = `${obj.text}$_#_$`;
    content += `${dom.labelText}`
  content += `$_#_$${dom.id}$_#_$${uuid}`;
  arr.splice(obj.startIndex, obj.endIndex - obj.startIndex + 1, content)
  return arr;
}
/**
 * 划词后 删除实体
 * @param  {Array} initArr 划词后数组
 */
export function getDeleteContent(initArr, index, text) {
    const changeArr = getContent(text);
    initArr.splice(index - 0, 1, changeArr[0]);
    for (let i = changeArr.length - 1; i > 0; i--) {
        initArr.splice(index - 0 + 1, 0, changeArr[i]);
    }
    return initArr;
}
/**
 * 查询 实体or关系 个数
 * @param  {Array} textArr 划词后数组
 * @param  {string} key 查询类型
 * @param {Array} labelList 标签列表
 */
export function getNum(textArr, key, labelList) {
    let num = 0;
    switch (key) {
      case 'relation':
        textArr.forEach(val => { if (val.indexOf('#_#') !== -1) num += val.split('#_#').length - 1 });
        break;
      // case 'instance':
      //   const labels = labelList.map(label => label.labelName);
      //   // 去重 计数
      //   let hasType = new Set()
      //   textArr.forEach(val => {
      //     let type = ''
      //     if (val.length > 1 && val.indexOf('$_#_$') !== -1) {
      //       type = val.split('$_#_$')[1]
      //       if (labels.indexOf(type) > -1) {
      //         hasType.add(type)
      //       }
      //     }
      //   });
      //   num = hasType.size
      //   break;
      case 'property':
      default: {
        const labels = labelList && labelList.map(label => label.labelName);
        textArr.forEach(val => {
          if (val.length > 1 && val.indexOf('$_#_$') !== -1 && labels.indexOf(val.split('$_#_$')[1])
            > -1) {
            num += 1;
          }
        });
      }
        break;
    }
    return num;
}


/**
 * 根据uuid 返回 索引   isBackTxt 是否返回索引加内容
 */
export function queryIndex(Arr, uuid, isBackTxt) {
    let num = 0;
    let text = '';
    Arr.map((val, i) => {
        const arr = val.split('$_#_$');
        if (arr[3] === uuid) {
            num = i;
            text = arr[0]
        }
    });
    return isBackTxt ? `${num} ${text}` : num;
}

/**
 * 根据uuid  label内容 标注的内容
 */
export function queryLabelContent(Arr, uuid) {
  let num = 0;
  let text = '';
  Arr.map((val, i) => {
    const arr = val.split('$_#_$');
    if (arr[3] === uuid) {
      num = i;
      text = arr[0]
    }
  });
  return text;
}

/**
 * 根据uuid 返回 title内容
 */
export function initTitle(Arr, relationArr) {
    if (!relationArr) {
        return '';
    }
    const backs = [];
    let fromId = Arr[3]
    const relation = relationArr.filter(val => val.split('#_$_#')[0] === fromId);
    relation.map(item=>{
      //疾病_症状 #  脑痨 # 0#a0a67a9d47ff4e1986b332b21c8037bd#2a236630ee6b47e9aafc1f64c335cf20
      backs.push(`${item.split('#_$_#')[1]} $_#_$_$_#  ${Arr[0]} $_#_$_$_# ${item[1]}$_#_$_$_#${item.split('#_$_#')[0]}$_#_$_$_#${item.split('#_$_#')[2]}`);
    })
    // Arr.map((val, i) => {
    //     if (i > 3) {
    //         const item = val.split('#_#');
    //         const relation = relationArr.filter(val => val.indexOf(item[0]) !== -1 && val.indexOf(Arr[3] !== -1));
    //         // console.log(relation)
    //         if (relation[0]) {
    //疾病_病因 #  脑肺吸虫病 # 吸虫成虫寄生于脑内并不断移行造成的机械性损伤，及其代谢物等引起的免疫病理反应的一种疾病，以颞叶最常受损。本病#02a79dd404da4b838f62abe343f53112#091933e34d0e4c648a23ea6a55748c12
    //             backs.push(`${relation[0].split('#_$_#')[1]} #  ${Arr[0]} # ${item[1]}#${relation[0].split('#_$_#')[0]}#${relation[0].split('#_$_#')[2]}`);
    //         }
    //     }
    // })
    return backs
}
/**
 * 清除 选中
 */
export const clearSelect = 'getSelection' in window ? function () {
    window.getSelection().removeAllRanges();
} : function () {
    document.selection.empty();
};

/**
 * 根据实体类别返回该实体类别的索引
 * @param objectLabels 实例标签列表
 * @param propLabels 属性标签列表
 * @param propertyIdArr 已标注的属性id列表
 * @param item 当前选中文字的标记信息 名称和id等数组
 * @return 颜色索引
 */
export function getIndexByContent(objectLabels, propLabels, propertyIdArr, item) {
  // console.log(item[1])
    let index = 0;
    const isProp = propertyIdArr && propertyIdArr.length > 0 &&
      propertyIdArr.indexOf(item[3]) > -1;
    if (isProp) {
      index = objectLabels.length + propLabels.findIndex(label => label.labelName === item[1]);
    } else {
      index = objectLabels.findIndex(label => label.labelName === item[1]);
    }
    // console.log(index)
    return index;
}
export function questionLabelGetIndexByContent(objectLabels, labelList) {

  // console.log(index)
  return labelList.findIndex(label => label.labelName === objectLabels[1]);
}
/**
 * 根据实体 id 返回该实体类别
 */
export function getTypeById(arr, id) {
    let type = '';
    arr.forEach(v => {
        if (v.length > 1) {
            const item = v.split('$_#_$');
            if (item[3] === id) {
                type = item[1];
            }
        }
    })
    return type
}


/**
 * 模型测试数据重构 - 实体
 */
export function getObjectTestData(data) {
    const arr = [];
    data.forEach(val => {
        val.entities.forEach(v => {
            arr.push({ ...v, sentence: val.sentence })
        })
    })
    return arr;
}

/**
 * 模型测试数据重构 - 关键字
 */
export function getKeyWordsTestData(data) {
  const arr = [];
  data.forEach(val => {
    arr.push({ keyword: val })
  })
  return arr;
}


/**
 * 模型测试数据 实体高亮
 */
export function setHash(data) {
    const hash = [];
    const content = getContent(data.sentence)
      data.entities.forEach(val => {
        for (let k = val.start; k < val.end; k++) {
          hash[k] = true;
        }
      });
    return getContent(data.sentence).map((v, i) => <span key={i} id={i} style={hash[i] ? { backgroundColor: '#29CCB1', color: '#fff' } : null}>{v}</span>)
}

/**
 * 对原始数组重新处理
 */
export function computeInitTxtArr(data) {
  let ret = {}
  data?.forEach((item, index) => {
    let arr = item.split("$_#_$")
    if (arr?.length > 1) {
      let [name, property, idx, id, ...rest] = arr
      if (!ret[id]) {
        ret[id] = {
          id, name, labelName: property, index, relationList: rest?.map((item) => {
            let [id, name] = item.split('#_#')
            return {
              id, name
            }
          })
        }
      }
    }
  });
  return ret
}
